Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_copy.pyc

Python Compiled Bytecode | 2005-10-18 | 35KB | 1,079 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

'''Unit tests for the copy module.'''
import sys
import copy
import copy_reg
import unittest
from test import test_support

class TestCopy(unittest.TestCase):

    def test_exceptions(self):
        self.assert_(copy.Error is copy.error)
        self.assert_(issubclass(copy.Error, Exception))


    def test_copy_basic(self):
        x = 42
        y = copy.copy(x)
        self.assertEqual(x, y)


    def test_copy_copy(self):

        class C(object):

            def __init__(self, foo):
                self.foo = foo


            def __copy__(self):
                return C(self.foo)


        x = C(42)
        y = copy.copy(x)
        self.assertEqual(y.__class__, x.__class__)
        self.assertEqual(y.foo, x.foo)


    def test_copy_registry(self):

        class C(object):

            def __new__(cls, foo):
                obj = object.__new__(cls)
                obj.foo = foo
                return obj



        def pickle_C(obj):
            return (C, (obj.foo,))

        x = C(42)
        self.assertRaises(TypeError, copy.copy, x)
        copy_reg.pickle(C, pickle_C, C)
        y = copy.copy(x)


    def test_copy_reduce_ex(self):

        class C(object):

            def __reduce_ex__(self, proto):
                return ''


            def __reduce__(self):
                raise test_support.TestFailed, "shouldn't call this"


        x = C()
        y = copy.copy(x)
        self.assert_(y is x)


    def test_copy_reduce(self):

        class C(object):

            def __reduce__(self):
                return ''


        x = C()
        y = copy.copy(x)
        self.assert_(y is x)


    def test_copy_cant(self):

        class C(object):

            def __getattribute__(self, name):
                if name.startswith('__reduce'):
                    raise AttributeError, name

                return object.__getattribute__(self, name)


        x = C()
        self.assertRaises(copy.Error, copy.copy, x)


    def test_copy_atomic(self):

        class Classic:
            pass


        class NewStyle(object):
            pass


        def f():
            pass

        tests = [
            None,
            42,
            0x2L ** 100,
            3.1400000000000001,
            True,
            False,
            (0.0+1.0j),
            'hello',
            u'hello\xe1\x88\xb4',
            f.func_code,
            NewStyle,
            xrange(10),
            Classic,
            max]
        for x in tests:
            self.assert_(copy.copy(x) is x, repr(x))



    def test_copy_list(self):
        x = [
            1,
            2,
            3]
        self.assertEqual(copy.copy(x), x)


    def test_copy_tuple(self):
        x = (1, 2, 3)
        self.assertEqual(copy.copy(x), x)


    def test_copy_dict(self):
        x = {
            'foo': 1,
            'bar': 2 }
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_vanilla(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_copy(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __copy__(self):
                return C(self.foo)


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_getinitargs(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getinitargs__(self):
                return (self.foo,)


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_getstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getstate__(self):
                return {
                    'foo': self.foo }


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_setstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __setstate__(self, state):
                self.foo = state['foo']


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_inst_getstate_setstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getstate__(self):
                return self.foo


            def __setstate__(self, state):
                self.foo = state


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C(42)
        self.assertEqual(copy.copy(x), x)


    def test_copy_classictype(self):
        make_copyable = make_copyable
        import _testcapi
        x = make_copyable([
            23])
        y = copy.copy(x)
        self.assertEqual(x, y)
        self.assertEqual(x.tag, y.tag)
        self.assert_(x is not y)
        self.assert_(x.tag is y.tag)


    def test_deepcopy_classictype(self):
        make_copyable = make_copyable
        import _testcapi
        x = make_copyable([
            23])
        y = copy.deepcopy(x)
        self.assertEqual(x, y)
        self.assertEqual(x.tag, y.tag)
        self.assert_(x is not y)
        self.assert_(x.tag is not y.tag)


    def test_copy_classoverinstance(self):

        class C(object):

            def __init__(self, v):
                self.v = v


            def __cmp__(self, other):
                return -cmp(other, self.v)


            def __copy__(self):
                return self.__class__(self.v)


        x = C(23)
        self.assertEqual(copy.copy(x), x)

        x.__copy__ = lambda : 42
        self.assertEqual(copy.copy(x), x)


    def test_deepcopy_classoverinstance(self):

        class C(object):

            def __init__(self, v):
                self.v = v


            def __cmp__(self, other):
                return -cmp(other, self.v)


            def __deepcopy__(self, memo):
                return self.__class__(copy.deepcopy(self.v, memo))


        x = C(23)
        self.assertEqual(copy.deepcopy(x), x)

        x.__deepcopy__ = lambda memo: 42
        self.assertEqual(copy.deepcopy(x), x)


    def test_copy_metaclassconfusion(self):

        class MyOwnError(copy.Error):
            pass


        class Meta(type):

            def __copy__(cls):
                raise MyOwnError("can't copy classes w/this metaclass")



        class C:
            __metaclass__ = Meta

            def __init__(self, tag):
                self.tag = tag


            def __cmp__(self, other):
                return -cmp(other, self.tag)


        self.assertRaises(MyOwnError, copy.copy, C)
        x = C(23)
        self.assertEqual(copy.copy(x), x)


    def test_deepcopy_metaclassconfusion(self):

        class MyOwnError(copy.Error):
            pass


        class Meta(type):

            def __deepcopy__(cls, memo):
                raise MyOwnError("can't deepcopy classes w/this metaclass")



        class C:
            __metaclass__ = Meta

            def __init__(self, tag):
                self.tag = tag


            def __cmp__(self, other):
                return -cmp(other, self.tag)


        self.assertEqual(copy.deepcopy(C), C)
        x = C(23)
        self.assertEqual(copy.deepcopy(x), x)


    def _nomro(self):

        class C(type):

            def __getattribute__(self, attr):
                if attr == '__mro__':
                    raise AttributeError, 'What, *me*, a __mro__? Nevah!'

                return super(C, self).__getattribute__(attr)



        class D(object):
            __metaclass__ = C

        return D()


    def test_copy_mro(self):
        x = self._nomro()
        y = copy.copy(x)


    def test_deepcopy_mro(self):
        x = self._nomro()
        y = copy.deepcopy(x)


    def test_deepcopy_basic(self):
        x = 42
        y = copy.deepcopy(x)
        self.assertEqual(y, x)


    def test_deepcopy_memo(self):
        x = []
        x = [
            x,
            x]
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y[0] is not x[0])
        self.assert_(y[0] is y[1])


    def test_deepcopy_issubclass(self):

        class Meta(type):
            pass


        class C:
            __metaclass__ = Meta

        self.assertEqual(copy.deepcopy(C), C)


    def test_deepcopy_deepcopy(self):

        class C(object):

            def __init__(self, foo):
                self.foo = foo


            def __deepcopy__(self, memo = None):
                return C(self.foo)


        x = C(42)
        y = copy.deepcopy(x)
        self.assertEqual(y.__class__, x.__class__)
        self.assertEqual(y.foo, x.foo)


    def test_deepcopy_registry(self):

        class C(object):

            def __new__(cls, foo):
                obj = object.__new__(cls)
                obj.foo = foo
                return obj



        def pickle_C(obj):
            return (C, (obj.foo,))

        x = C(42)
        self.assertRaises(TypeError, copy.deepcopy, x)
        copy_reg.pickle(C, pickle_C, C)
        y = copy.deepcopy(x)


    def test_deepcopy_reduce_ex(self):

        class C(object):

            def __reduce_ex__(self, proto):
                return ''


            def __reduce__(self):
                raise test_support.TestFailed, "shouldn't call this"


        x = C()
        y = copy.deepcopy(x)
        self.assert_(y is x)


    def test_deepcopy_reduce(self):

        class C(object):

            def __reduce__(self):
                return ''


        x = C()
        y = copy.deepcopy(x)
        self.assert_(y is x)


    def test_deepcopy_cant(self):

        class C(object):

            def __getattribute__(self, name):
                if name.startswith('__reduce'):
                    raise AttributeError, name

                return object.__getattribute__(self, name)


        x = C()
        self.assertRaises(copy.Error, copy.deepcopy, x)


    def test_deepcopy_atomic(self):

        class Classic:
            pass


        class NewStyle(object):
            pass


        def f():
            pass

        tests = [
            None,
            42,
            0x2L ** 100,
            3.1400000000000001,
            True,
            False,
            (0.0+1.0j),
            'hello',
            u'hello\xe1\x88\xb4',
            f.func_code,
            NewStyle,
            xrange(10),
            Classic,
            max]
        for x in tests:
            self.assert_(copy.deepcopy(x) is x, repr(x))



    def test_deepcopy_list(self):
        x = [
            [
                1,
                2],
            3]
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(x is not y)
        self.assert_(x[0] is not y[0])


    def test_deepcopy_reflexive_list(self):
        x = []
        x.append(x)
        y = copy.deepcopy(x)
        self.assertRaises(RuntimeError, cmp, y, x)
        self.assert_(y is not x)
        self.assert_(y[0] is y)
        self.assertEqual(len(y), 1)


    def test_deepcopy_tuple(self):
        x = ([
            1,
            2], 3)
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(x is not y)
        self.assert_(x[0] is not y[0])


    def test_deepcopy_reflexive_tuple(self):
        x = ([],)
        x[0].append(x)
        y = copy.deepcopy(x)
        self.assertRaises(RuntimeError, cmp, y, x)
        self.assert_(y is not x)
        self.assert_(y[0] is not x[0])
        self.assert_(y[0][0] is y)


    def test_deepcopy_dict(self):
        x = {
            'foo': [
                1,
                2],
            'bar': 3 }
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(x is not y)
        self.assert_(x['foo'] is not y['foo'])


    def test_deepcopy_reflexive_dict(self):
        x = { }
        x['foo'] = x
        y = copy.deepcopy(x)
        self.assertRaises(RuntimeError, cmp, y, x)
        self.assert_(y is not x)
        self.assert_(y['foo'] is y)
        self.assertEqual(len(y), 1)


    def test_deepcopy_keepalive(self):
        memo = { }
        x = 42
        y = copy.deepcopy(x, memo)
        self.assert_(memo[id(x)] is x)


    def test_deepcopy_inst_vanilla(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_inst_deepcopy(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __deepcopy__(self, memo):
                return C(copy.deepcopy(self.foo, memo))


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_inst_getinitargs(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getinitargs__(self):
                return (self.foo,)


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_inst_getstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getstate__(self):
                return {
                    'foo': self.foo }


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_inst_setstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __setstate__(self, state):
                self.foo = state['foo']


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_inst_getstate_setstate(self):

        class C:

            def __init__(self, foo):
                self.foo = foo


            def __getstate__(self):
                return self.foo


            def __setstate__(self, state):
                self.foo = state


            def __cmp__(self, other):
                return cmp(self.foo, other.foo)


        x = C([
            42])
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y is not x)
        self.assert_(y.foo is not x.foo)


    def test_deepcopy_reflexive_inst(self):

        class C:
            pass

        x = C()
        x.foo = x
        y = copy.deepcopy(x)
        self.assert_(y is not x)
        self.assert_(y.foo is y)


    def test_reconstruct_string(self):

        class C(object):

            def __reduce__(self):
                return ''


        x = C()
        y = copy.copy(x)
        self.assert_(y is x)
        y = copy.deepcopy(x)
        self.assert_(y is x)


    def test_reconstruct_nostate(self):

        class C(object):

            def __reduce__(self):
                return (C, ())


        x = C()
        x.foo = 42
        y = copy.copy(x)
        self.assert_(y.__class__ is x.__class__)
        y = copy.deepcopy(x)
        self.assert_(y.__class__ is x.__class__)


    def test_reconstruct_state(self):

        class C(object):

            def __reduce__(self):
                return (C, (), self.__dict__)


            def __cmp__(self, other):
                return cmp(self.__dict__, other.__dict__)


        x = C()
        x.foo = [
            42]
        y = copy.copy(x)
        self.assertEqual(y, x)
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y.foo is not x.foo)


    def test_reconstruct_state_setstate(self):

        class C(object):

            def __reduce__(self):
                return (C, (), self.__dict__)


            def __setstate__(self, state):
                self.__dict__.update(state)


            def __cmp__(self, other):
                return cmp(self.__dict__, other.__dict__)


        x = C()
        x.foo = [
            42]
        y = copy.copy(x)
        self.assertEqual(y, x)
        y = copy.deepcopy(x)
        self.assertEqual(y, x)
        self.assert_(y.foo is not x.foo)


    def test_reconstruct_reflexive(self):

        class C(object):
            pass

        x = C()
        x.foo = x
        y = copy.deepcopy(x)
        self.assert_(y is not x)
        self.assert_(y.foo is y)


    def test_reduce_4tuple(self):

        class C(list):

            def __reduce__(self):
                return (C, (), self.__dict__, iter(self))


            def __cmp__(self, other):
                if not cmp(list(self), list(other)):
                    pass
                return cmp(self.__dict__, other.__dict__)


        x = C([
            [
                1,
                2],
            3])
        y = copy.copy(x)
        self.assertEqual(x, y)
        self.assert_(x is not y)
        self.assert_(x[0] is y[0])
        y = copy.deepcopy(x)
        self.assertEqual(x, y)
        self.assert_(x is not y)
        self.assert_(x[0] is not y[0])


    def test_reduce_5tuple(self):

        class C(dict):

            def __reduce__(self):
                return (C, (), self.__dict__, None, self.iteritems())


            def __cmp__(self, other):
                if not cmp(dict(self), list(dict)):
                    pass
                return cmp(self.__dict__, other.__dict__)


        x = C([
            ('foo', [
                1,
                2]),
            ('bar', 3)])
        y = copy.copy(x)
        self.assertEqual(x, y)
        self.assert_(x is not y)
        self.assert_(x['foo'] is y['foo'])
        y = copy.deepcopy(x)
        self.assertEqual(x, y)
        self.assert_(x is not y)
        self.assert_(x['foo'] is not y['foo'])


    def test_copy_slots(self):

        class C(object):
            __slots__ = [
                'foo']

        x = C()
        x.foo = [
            42]
        y = copy.copy(x)
        self.assert_(x.foo is y.foo)


    def test_deepcopy_slots(self):

        class C(object):
            __slots__ = [
                'foo']

        x = C()
        x.foo = [
            42]
        y = copy.deepcopy(x)
        self.assertEqual(x.foo, y.foo)
        self.assert_(x.foo is not y.foo)


    def test_copy_list_subclass(self):

        class C(list):
            pass

        x = C([
            [
                1,
                2],
            3])
        x.foo = [
            4,
            5]
        y = copy.copy(x)
        self.assertEqual(list(x), list(y))
        self.assertEqual(x.foo, y.foo)
        self.assert_(x[0] is y[0])
        self.assert_(x.foo is y.foo)


    def test_deepcopy_list_subclass(self):

        class C(list):
            pass

        x = C([
            [
                1,
                2],
            3])
        x.foo = [
            4,
            5]
        y = copy.deepcopy(x)
        self.assertEqual(list(x), list(y))
        self.assertEqual(x.foo, y.foo)
        self.assert_(x[0] is not y[0])
        self.assert_(x.foo is not y.foo)


    def test_copy_tuple_subclass(self):

        class C(tuple):
            pass

        x = C([
            1,
            2,
            3])
        self.assertEqual(tuple(x), (1, 2, 3))
        y = copy.copy(x)
        self.assertEqual(tuple(y), (1, 2, 3))


    def test_deepcopy_tuple_subclass(self):

        class C(tuple):
            pass

        x = C([
            [
                1,
                2],
            3])
        self.assertEqual(tuple(x), ([
            1,
            2], 3))
        y = copy.deepcopy(x)
        self.assertEqual(tuple(y), ([
            1,
            2], 3))
        self.assert_(x is not y)
        self.assert_(x[0] is not y[0])


    def test_getstate_exc(self):

        class EvilState(object):

            def __getstate__(self):
                raise ValueError, "ain't got no stickin' state"


        self.assertRaises(ValueError, copy.copy, EvilState())



def test_main():
    test_support.run_unittest(TestCopy)

if __name__ == '__main__':
    test_main()